{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "先对标准基作线性变换后，再那该结果操作另一个向量和直接对另一个向量作相同线性变换得到的结果是一样的吗？(以下为deepdeek的解答)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 问题分析\n",
    "- 设有一个线性变换 \\( $T: \\mathbb{R}^n \\to \\mathbb{R}^m$ \\)（假设向量空间是有限维欧几里得空间，标准基是 \\( \\{$e_1, e_2, \\dots, e_n$\\} \\)）。\n",
    "- “另一个向量” 记为 \\( $v \\in \\mathbb{R}^n$ \\)。\n",
    "- 你的问题可以拆分为两种操作方式：\n",
    "  1. **先对标准基作线性变换，再用结果操作另一个向量**：先计算 \\( $T(e_1), T(e_2), \\dots, T(e_n)$ \\)，然后基于这些结果和 \\( $v$ \\) 计算一个新向量（具体操作方式稍后解释）。\n",
    "  2. **直接对另一个向量作相同线性变换**：直接计算 \\( $T(v)$ \\)。\n",
    "\n",
    "关键点在于“用结果操作另一个向量”的含义。根据线性代数的标准理解，这通常是指：\n",
    "- 将 \\( $v$ \\) 表示为标准基的线性组合：\\( $v = c_1 e_1 + c_2 e_2 + \\dots + c_n e_n$ \\)，其中 \\( $c_i$ \\) 是标量（在标准基下，这些 \\( $c_i$ \\) 就是 \\( v \\) 的分量）。\n",
    "- 然后用相同的系数 \\( $c_i$ \\) 与变换后的基向量 \\( $T(e_i)$ \\) 组合，得到 \\( $\\sum_{i=1}^n c_i T(e_i)$ \\).\n",
    "\n",
    "### 为什么结果相同？\n",
    "线性变换的定义要求它满足以下性质：\n",
    "\\[\n",
    "$T(c_1 \\mathbf{v}_1 + c_2 \\mathbf{v}_2) = c_1 T(\\mathbf{v}_1) + c_2 T(\\mathbf{v}_2)$\n",
    "\\]\n",
    "对于任意向量和标量成立。因此，对于 \\( v = \\sum_{i=1}^n c_i e_i \\)，有：\n",
    "\\[\n",
    "$T(v) = T\\left( \\sum_{i=1}^n c_i e_i \\right) = \\sum_{i=1}^n c_i T(e_i).$\n",
    "\\]\n",
    "这正是上述第一种操作方式的结果。所以：\n",
    "- **先变换标准基再组合**：得到 \\( $\\sum_{i=1}^n c_i T(e_i)$ \\)。\n",
    "- **直接变换 \\( v \\)**：得到 \\( T(v) \\)。\n",
    "\n",
    "二者相等。\n",
    "\n",
    "### 矩阵视角（可选，帮助理解）\n",
    "如果使用矩阵表示线性变换，结论更直观：\n",
    "- 线性变换 \\( T \\) 对应一个矩阵 \\( A \\)（大小为 \\( $m \\times n$ \\))，其中第 \\( i \\) 列就是 \\( $T(e_i)$ \\)。\n",
    "- 对标准基作变换：得到矩阵 \\( A \\)。\n",
    "- “用结果操作另一个向量”：即计算矩阵-向量乘法 \\( A v \\)。\n",
    "- 直接对 \\( v \\) 作变换：也是计算 \\( $T(v) = A v$ \\)。\n",
    "\n",
    "因此，结果完全相同，都是 \\( A v \\)。\n",
    "\n",
    "### 示例说明\n",
    "考虑一个简单例子。设 \\( $\\mathbb{R}^2$ \\) 中的标准基为 \\($ e_1 = \\begin{bmatrix} 1 \\\\ 0 \\end{bmatrix}, e_2 = \\begin{bmatrix} 0 \\\\ 1 \\end{bmatrix}$ \\)，另一个向量 \\( $v = \\begin{bmatrix} 3 \\\\ 2 \\end{bmatrix}$ \\)。线性变换 \\( T \\) 定义为：\n",
    "\\[\n",
    "$T\\left( \\begin{bmatrix} x \\\\ y \\end{bmatrix} \\right) = \\begin{bmatrix} 2x - y \\\\ x + 3y \\end{bmatrix}.$\n",
    "\\]\n",
    "\n",
    "- **先对标准基作变换**：\n",
    "  - \\( $T(e_1) = T\\left( \\begin{bmatrix} 1 \\\\ 0 \\end{bmatrix} \\right) = \\begin{bmatrix} 2(1) - 0 \\\\ 1 + 3(0) \\end{bmatrix} = \\begin{bmatrix} 2 \\\\ 1 \\end{bmatrix} $\\)，\n",
    "  - \\( $T(e_2) = T\\left( \\begin{bmatrix} 0 \\\\ 1 \\end{bmatrix} \\right) = \\begin{bmatrix} 2(0) - 1 \\\\ 0 + 3(1) \\end{bmatrix} = \\begin{bmatrix} -1 \\\\ 3 \\end{bmatrix} $\\).\n",
    "\n",
    "- **再用结果操作 \\( v \\)**：  \n",
    "  \\( $v = \\begin{bmatrix} 3 \\\\ 2 \\end{bmatrix} = 3 e_1 + 2 e_2 $\\)，所以组合为：  \n",
    "  \\( $3 T(e_1) + 2 T(e_2) = 3 \\begin{bmatrix} 2 \\\\ 1 \\end{bmatrix} + 2 \\begin{bmatrix} -1 \\\\ 3 \\end{bmatrix} = \\begin{bmatrix} 6 \\\\ 3 \\end{bmatrix} + \\begin{bmatrix} -2 \\\\ 6 \\end{bmatrix} = \\begin{bmatrix} 4 \\\\ 9 \\end{bmatrix} $\\).\n",
    "\n",
    "- **直接对 \\( v \\) 作变换**：  \n",
    "  \\( $T(v) = T\\left( \\begin{bmatrix} 3 \\\\ 2 \\end{bmatrix} \\right) = \\begin{bmatrix} 2(3) - 2 \\\\ 3 + 3(2) \\end{bmatrix} = \\begin{bmatrix} 6 - 2 \\\\ 3 + 6 \\end{bmatrix} = \\begin{bmatrix} 4 \\\\ 9 \\end{bmatrix}$ \\).\n",
    "\n",
    "结果一致，都是 \\( $\\begin{bmatrix} 4 \\\\ 9 \\end{bmatrix} $\\)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5.1 用矩阵表示变换"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "sys.path.append('E:/CodeFile/python/mathematics-for-programmers/pyfile')\n",
    "from PersonalTools.Multidimensional import *\n",
    "\n",
    "# 矩阵和向量相乘\n",
    "def multiply_matrix_vector(matrix, vector):\n",
    "  return linear_combination(vector, *zip(*matrix))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, -2, -2)"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B = ((0,2,1),(0,1,0),(1,0,-1))\n",
    "v = (3,-2,5)\n",
    "\n",
    "multiply_matrix_vector(B,v)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "sys.path.append('E:/CodeFile/python/mathematics-for-programmers/pyfile')\n",
    "from ExternalTools.vectors import *\n",
    "\n",
    "def matrix_multiply(a, b):\n",
    "  return tuple(\n",
    "    tuple(dot(row,col) for col in zip(*b)) for row in a\n",
    "  )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((0, 3, 1), (1, 2, 0), (1, 1, 0))"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = ((1,1,0),(1,0,1),(1,-1,1))\n",
    "b = ((0,2,1),(0,1,0),(1,0,-1))\n",
    "\n",
    "matrix_multiply(a,b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 矩阵相乘\n",
    "计算规则：\n",
    "1. 结果矩阵 C 中的元素 cᵢⱼ（位于第 i 行，第 j 列）的值是这样计算的：\n",
    "2. 选取行和列： 取 A 的第 i 行（一个包含 n 个元素的向量）。\n",
    "3. 选取列： 取 B 的第 j 列（一个包含 n 个元素的向量）。\n",
    "4. 点积（内积）： 将 A 的第 i 行中的每一个元素与 B 的第 j 列中**对应**(对应位置没元素是以0代替)位置的元素相乘。\n",
    "5. 求和： 将所有 n 个乘积的结果相加。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "关键前提条件：\n",
    "\n",
    "两个矩阵 A 和 B 能够相乘（A × B）当且仅当：\n",
    "\n",
    "第一个矩阵 A 的列数 等于 第二个矩阵 B 的行数。\n",
    "\n",
    "表示法：\n",
    "\n",
    "设矩阵 A 的维度是 m × n（m 行，n 列）。\n",
    "\n",
    "设矩阵 B 的维度是 n × p（n 行，p 列）。\n",
    "\n",
    "那么，它们的乘积 C = A × B 将是一个维度为 m × p（m 行，p 列）的新矩阵。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 单位矩阵\n",
    "\n",
    "在线性代数中，**单位矩阵（Identity Matrix）** 是一个极其重要且基础的概念，它在线性变换和矩阵运算中扮演的角色，类似于数字 “1” 在标量乘法中的角色——**它是矩阵乘法的“单位元”**。\n",
    "\n",
    "### 核心定义\n",
    "\n",
    "1.  **方阵：** 单位矩阵首先必须是一个**方阵**，即行数和列数相等（n × n）。\n",
    "2.  **对角线元素为 1：** 在矩阵的**主对角线**（从左上角到右下角）上的所有元素都是 **1**。\n",
    "3.  **非对角线元素为 0：** 主对角线以外的所有元素都是 **0**。\n",
    "\n",
    "### 表示法\n",
    "*   一个 **n 阶单位矩阵**通常用符号 **Iₙ** 或简写为 **I** 表示（当阶数从上下文可明确时）。\n",
    "*   数学上可以表示为：\n",
    "    `Iₙ = [δᵢⱼ]`\n",
    "    其中 **δᵢⱼ** 是 **克罗内克δ函数（Kronecker delta）**：\n",
    "    *   δᵢⱼ = 1 (当 i = j 时)\n",
    "    *   δᵢⱼ = 0 (当 i ≠ j 时)\n",
    "\n",
    "### 示例\n",
    "*   **2 阶单位矩阵 (I₂)：**\n",
    "    ```\n",
    "    I₂ = [1  0]\n",
    "         [0  1]\n",
    "    ```\n",
    "*   **3 阶单位矩阵 (I₃)：**\n",
    "    ```\n",
    "    I₃ = [1  0  0]\n",
    "         [0  1  0]\n",
    "         [0  0  1]\n",
    "    ```\n",
    "*   **n 阶单位矩阵 (Iₙ)：**\n",
    "    ```\n",
    "    Iₙ = [1  0  0  ...  0]\n",
    "         [0  1  0  ...  0]\n",
    "         [0  0  1  ...  0]\n",
    "         [... ... ... ...]\n",
    "         [0  0  0  ...  1]\n",
    "    ```\n",
    "\n",
    "### 核心性质：矩阵乘法的单位元\n",
    "单位矩阵最核心、最重要的性质就是它与任何**兼容维度**的矩阵相乘，都会**保持原矩阵不变**：\n",
    "\n",
    "1.  **左乘单位矩阵：** 如果 **A** 是一个 **m × n** 矩阵，那么用 **m 阶单位矩阵 Iₘ** 左乘 **A**，结果仍是 **A**。\n",
    "    *   **Iₘ × A = A**\n",
    "    *   **意义：** Iₘ 的 m 行分别与 A 的每一列做点积。Iₘ 的第 i 行只在第 i 列是 1，其他是 0。它与 A 的第 j 列做点积时，只会“挑选”出 A 的第 i 行、第 j 列的元素 aᵢⱼ，并将其放到结果矩阵的 (i, j) 位置。因此，结果就是 A 本身。\n",
    "\n",
    "2.  **右乘单位矩阵：** 如果 **A** 是一个 **m × n** 矩阵，那么用 **n 阶单位矩阵 Iₙ** 右乘 **A**，结果仍是 **A**。\n",
    "    *   **A × Iₙ = A**\n",
    "    *   **意义：** A 的每一行分别与 Iₙ 的每一列做点积。Iₙ 的第 j 列只在第 j 行是 1，其他是 0。当 A 的第 i 行与 Iₙ 的第 j 列做点积时，只会“挑选”出 A 的第 i 行、第 j 列的元素 aᵢⱼ，并将其放到结果矩阵的 (i, j) 位置。因此，结果也是 A 本身。\n",
    "\n",
    "### 示例说明\n",
    "设矩阵 A 为：\n",
    "```\n",
    "A = [2  5]\n",
    "    [7  3]\n",
    "    [1  8]  (这是一个 3×2 矩阵)\n",
    "```\n",
    "*   **左乘 I₃ (3阶单位矩阵)：**\n",
    "    ```\n",
    "        I₃          ×         A          =         A\n",
    "    [1  0  0]     [2  5]               [2  5]\n",
    "    [0  1  0]  ×  [7  3]    =        [7  3]\n",
    "    [0  0  1]     [1  8]               [1  8]\n",
    "    ```\n",
    "    计算 c₁₁ = (1*2) + (0*7) + (0*1) = 2\n",
    "    计算 c₁₂ = (1*5) + (0*3) + (0*8) = 5\n",
    "    计算 c₂₁ = (0*2) + (1*7) + (0*1) = 7\n",
    "    以此类推，结果等于 A。\n",
    "\n",
    "*   **右乘 I₂ (2阶单位矩阵)：**\n",
    "    ```\n",
    "          A          ×         I₂          =         A\n",
    "    [2  5]     [1  0]               [2  5]\n",
    "    [7  3]  ×  [0  1]    =        [7  3]\n",
    "    [1  8]                         [1  8]\n",
    "    ```\n",
    "    计算 c₁₁ = (2*1) + (5*0) = 2\n",
    "    计算 c₁₂ = (2*0) + (5*1) = 5\n",
    "    计算 c₂₁ = (7*1) + (3*0) = 7\n",
    "    以此类推，结果也等于 A。\n",
    "\n",
    "### 为什么重要？意义何在？\n",
    "1.  **乘法单位元：** 正如数字 1 是标量乘法的单位元 (1 * a = a * 1 = a)，单位矩阵是矩阵乘法的单位元 (I × A = A × I = A)。这是代数系统的基本要素。\n",
    "2.  **线性变换的“恒等变换”：** 在几何上，矩阵代表线性变换（旋转、缩放、剪切等）。**单位矩阵 Iₙ 代表的线性变换是“什么也不做”**，称为**恒等变换（Identity Transformation）**。它将 n 维空间中的每一个向量都映射到它自身。\n",
    "3.  **矩阵求逆的基础：** 矩阵 **A** 的逆矩阵 **A⁻¹** 定义的核心方程就是：**A × A⁻¹ = A⁻¹ × A = I**。单位矩阵是定义逆矩阵的基准。\n",
    "4.  **解线性方程组：** 在求解方程组 **A𝐱 = 𝐛** 时，如果 **A** 可逆，解就是 **𝐱 = A⁻¹𝐛**。这本质上是通过找到 A⁻¹，将原方程转化为 **I𝐱 = A⁻¹𝐛**，即 **𝐱 = A⁻¹𝐛**。\n",
    "5.  **特征值和特征向量：** 特征方程定义为 **det(A - λI) = 0**。单位矩阵 **I** 在这里用于构造矩阵 **(A - λI)**，这是求解特征值 λ 的关键步骤。\n",
    "6.  **初等矩阵：** 代表行初等变换（行交换、行倍乘、行倍加）的矩阵，其逆矩阵很容易求出，并且这些初等矩阵相乘可以构造出可逆矩阵。单位矩阵是进行这些行变换的起点。\n",
    "\n",
    "### 总结\n",
    "单位矩阵 **I** 是一个主对角线上元素全为 1、其余元素全为 0 的**方阵**。它的核心作用在于：\n",
    "\n",
    "*   **I × A = A** （用与 A 行数相同的 I 左乘）\n",
    "*   **A × I = A** （用与 A 列数相同的 I 右乘）\n",
    "\n",
    "它在线性代数中扮演着“**恒等变换**”和“**乘法单位元**”的角色，是理解矩阵运算、线性变换、矩阵求逆、特征值问题等几乎所有核心概念的基石。其简单性掩盖了其基础性和重要性。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5.2 不同形状矩阵的含义"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "python3.8",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.20"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
